/**
 * File관련 공통모듈
 * 
 * @author KJH
 * @version 1.0, 2012-02-28 
 * @fix([수정자]) [yyyy-mm-dd]: [수정 내용]
 *
 */

/**
 * 함수 리스트
 * 
 * fileCopyNIO : 파일복사
 * fileMoveNIO : 파일이동
 * fileMoveSectionNIO : 파일의 특정부분 대체 
 * fileLockMoveNIO : 파일이동(File Locking)
 * getLineFileData : 라인단위로 파일의 내용을 읽는다.
 * getFileData : 파일에서 내용을 읽어서 리턴한다.
 * getNIOFileData : 파일을 NIO형식으로 읽어옴
 * getLockNIOFileData : 파일을 NIO형식으로 읽어옴(File Locking)
 * getNIORandomFileData : 파일의 특정부분의 내용을 NIO형식으로 읽어옴
 * getLockNIORandomFileData : 파일의 특정부분의 내용을 NIO형식으로 읽어옴(File Locking)
 * getIOFileData : 파일을 IO형식으로 읽어옴
 * setFileData : 내용을 파일로 출력
 * setNIOFileData : 내용을 NIO을 이용해서 파일로 출력
 * setNIORandomFileData : 파일의 내용을 특정부분에 추가시킨다.
 * setNIORandomFileDataOfString : 문자열을 추가한다.
 * setRandomFileDataOfStream : InputStream의 내용을 특정부분에 추가시킨다.
 * setIOFileData : 내용을 파일로 출력
 * getFilePath : 파일의 디렉토리 뒤에 File.separator를 추가
 * getPath : 관련 path를 리턴한다.
 * clearUploadFile : 디렉토리에 존재하는 파일을 삭제한다. 
 *
 */

package com.ubst.smartad.common;

import java.io.File;
import java.io.FileReader;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
import java.nio.channels.FileLock;
import java.nio.ByteBuffer;

import com.ubst.smartad.common.DataByteBuffer;
import com.ubst.smartad.common.StringUtil;

public class FileUtil{

	public static final int BUFFER = 1024;

	public FileUtil(){
	}
	
	/**
	 * 파일을 다른곳으로 복사
	 * 
	 * @param from : 복사할 원본파일 전체경로
	 * @param to : 복사되어질 전체경로
	 * @return 복사결과
	 *
	*/
	public static boolean fileCopyNIO(String from, String to) throws Exception{
		boolean trans_flag = true;
		FileInputStream fis = null;
		FileOutputStream fos = null;
		FileChannel in = null;
		FileChannel out = null;
		try{
			fis = new FileInputStream(from);
			fos = new FileOutputStream(to);
			in = fis.getChannel();
			out = fos.getChannel();
			in.transferTo(0,in.size(),out);
		}catch(Exception e){
			trans_flag = false;	
			throw e;
		}finally{
			if(out!=null){
				try{ out.close(); }catch(Exception ee){}
			}	
			if(in!=null){
				try{ in.close(); }catch(Exception ee){}
			}	
			if(fos!=null){
				try{ fos.close(); }catch(Exception ee){}
			}	
			if(fis!=null){
				try{ fis.close(); }catch(Exception ee){}
			}	
		}
		return trans_flag;
	}

	/**
	 * 파일을 다른곳으로 이동
	 * 
	 * @param from : 이동할 원본파일 전체경로
	 * @param to : 이동되어질 전체경로
	 * @return 이동결과
	 *
	*/
	public static boolean fileMoveNIO(String from, String to) throws Exception{
		boolean trans_flag = true;
		FileInputStream fis = null;
		FileOutputStream fos = null;
		FileChannel in = null;
		FileChannel out = null;
		File from_path = new File(from);
		try{
			fis = new FileInputStream(from);
			fos = new FileOutputStream(to);
			in = fis.getChannel();
			out = fos.getChannel();
			in.transferTo(0,in.size(),out);

			from_path.delete();
		}catch(Exception e){
			trans_flag = false;	
			throw e;
		}finally{
			if(out!=null){
				try{ out.close(); }catch(Exception ee){}
			}	
			if(in!=null){
				try{ in.close(); }catch(Exception ee){}
			}	
			if(fos!=null){
				try{ fos.close(); }catch(Exception ee){}
			}	
			if(fis!=null){
				try{ fis.close(); }catch(Exception ee){}
			}	
		}
		return trans_flag;
	}

	/**
	 * 기존파일에 내용을 추가한다 
	 * 
	 * @param from : 이동할 원본파일 전체경로
	 * @param to : 이동되어질 전체경로
	 * @param s_pos : 옮겨질파일의 시작위치 
	 * @param trans_size : 옮겨질파일의 사이즈  
	 * @param seek_pos : 추가할 기존 파일의 위치  
	 * @param lock_flag : 파일 Lock 유무   
	 * @return 결과 
	 *
	*/
	public static boolean fileMoveSectionNIO(String from, String to, long s_pos, long trans_size, long seek_pos, boolean lock_flag) throws Exception{
		boolean trans_flag = true;
		FileInputStream fis = null;
		RandomAccessFile fos = null;
		FileChannel in = null;
		FileChannel out = null;
		FileLock flock = null;
		File from_path = new File(from);
		try{
			fis = new FileInputStream(from);
			fos = new RandomAccessFile(to,"rw");
			fos.seek(seek_pos);
			
			in = fis.getChannel();
			out = fos.getChannel();
			
			if(lock_flag){
				while(true){
					flock = out.tryLock();
					if(flock!=null){
						in.transferTo(s_pos,trans_size,out);
						break;
					}
					Thread.sleep(100);		// 밀리초단위
				}
			}else{
				in.transferTo(s_pos,trans_size,out);
			}

			from_path.delete();
		}catch(Exception e){
			trans_flag = false;	
			throw e;
		}finally{
			if (flock != null && flock.isValid()){
				try{ flock.release(); }catch(Exception ee){}
			}     
			if(out!=null){
				try{ out.close(); }catch(Exception ee){}
			}	
			if(in!=null){
				try{ in.close(); }catch(Exception ee){}
			}	
			if(fos!=null){
				try{ fos.close(); }catch(Exception ee){}
			}	
			if(fis!=null){
				try{ fis.close(); }catch(Exception ee){}
			}	
		}
		return trans_flag;
	}

	/**
	 * 파일을 다른곳으로 이동(File Locking)
	 * 
	 * @param from : 이동할 원본파일 전체경로
	 * @param to : 이동되어질 전체경로
	 * @return 이동결과
	 *
	*/
	public static boolean fileLockMoveNIO(String from, String to) throws Exception{
		boolean trans_flag = true;
		FileInputStream fis = null;
		FileOutputStream fos = null;
		FileChannel in = null;
		FileChannel out = null;
		FileLock flock = null;
		File from_path = new File(from);
		try{
			fis = new FileInputStream(from);
			fos = new FileOutputStream(to);
			in = fis.getChannel();
			out = fos.getChannel();

			while(true){
				flock = out.tryLock();
				if(flock!=null){
					in.transferTo(0,in.size(),out);
					from_path.delete();
					break;
				}
				Thread.sleep(100);		// 밀리초단위
			}

		}catch(Exception e){
			trans_flag = false;	
			throw e;
		}finally{
			if (flock != null && flock.isValid()){
				try{ flock.release(); }catch(Exception ee){}
			}     
			if(out!=null){
				try{ out.close(); }catch(Exception ee){}
			}	
			if(in!=null){
				try{ in.close(); }catch(Exception ee){}
			}	
			if(fos!=null){
				try{ fos.close(); }catch(Exception ee){}
			}	
			if(fis!=null){
				try{ fis.close(); }catch(Exception ee){}
			}	
		}
		return trans_flag;
	}

	/**
	 * 파읠의 내용을 IO방식으로 가져온다.
	 *
	 * @param from : 내용을 가져올 파일의 전체경로
	 *
	 * @return 파일내용
	 *
	 */
	public static String getLineFileData(String from) throws Exception {

		StringBuffer strbuf_data = new StringBuffer();
		FileReader fis = null;
		BufferedReader in = null;

		try{
			fis = new FileReader(from);
			in = new BufferedReader(fis);

			for( String str_line; (str_line=in.readLine()) != null; ) {
				strbuf_data.append(str_line).append("\n");
			}

		}catch(Exception e){
			throw e;
		}finally{
			if(fis!=null){
				try{ fis.close(); }catch(Exception ee){}
			}	
			if(in!=null){
				try{ in.close(); }catch(Exception ee){}
			}	
		}
		return strbuf_data.toString();
	}

	/**
	 * 파읠의 내용을 가져온다.
	 * 
	 * @param from : 내용을 가져올 파일의 전체경로
	 * @param iotype : 파일내용을 가져오는 방식(IO, NIO)
	 * @return 파일내용
	 *
	*/
	public static String getFileData(String from, String iotype) throws Exception {
		// 아직은 NIO의 속도가 IO보다 약간느려 보임
		// 추후 사용할 수 있을지몰라 NIO방식을 구현하였음
		if(iotype!=null && iotype.equals("NIO")){	
			return getNIOFileData(from);
		}else{
			return getIOFileData(from);
		}
	}

	/**
	 * 파읠의 내용을 NIO방식으로 가져온다.
	 *
	 * @param from : 내용을 가져올 파일의 전체경로
	 * @return 파일내용
	 *
	*/
	public static String getNIOFileData(String from) throws Exception {

		String str_data = "";
		FileInputStream fis = null;
		FileChannel in = null;
		
		try{
			File fi = new File(from) ;

			if(fi.exists()){
				fis = new FileInputStream(fi);
				in = fis.getChannel();

				DataByteBuffer byteBuffer = new DataByteBuffer();

				ByteBuffer buf = ByteBuffer.allocateDirect( BUFFER );
				byte[] array_byte = null;
				int ret = 0;

				while((ret = in.read(buf)) != -1) {
					if ( ret != -1 ) {
						buf.flip() ;
						array_byte = new byte[ret];
						buf.get(array_byte);
						byteBuffer.append(array_byte);
						buf.clear() ;
					}else{
						break;        // -1(화일끝)이 나오면 루프를 멈춥
					}

				}

				str_data = new String(byteBuffer.toByte());
			}

		}catch(Exception e){
			throw e;
		}finally{
			if(in!=null){
				try{ in.close(); }catch(Exception ee){}
			}	
			if(fis!=null){
				try{ fis.close(); }catch(Exception ee){}
			}	
		}
		return str_data;
	}

	/**
	 * 파읠의 내용을 NIO방식으로 가져온다(File Locking)
	 *
	 * @param from : 내용을 가져올 파일의 전체경로
	 * @return 파일내용
	 *
	*/
	public static String getLockNIOFileData(String from) throws Exception {

		String str_data = "";
		FileInputStream fis = null;
		FileChannel in = null;
		FileLock flock = null;
		
		try{
			File fi = new File(from) ;

			if(fi.exists()){
				fis = new FileInputStream(fi);
				in = fis.getChannel();

				while(true){
					flock = in.tryLock();
					if(flock!=null){
						DataByteBuffer byteBuffer = new DataByteBuffer();

						ByteBuffer buf = ByteBuffer.allocateDirect( BUFFER );
						byte[] array_byte = null;
						int ret = 0;

						while((ret = in.read(buf)) != -1) {
							if ( ret != -1 ) {
								buf.flip() ;
								array_byte = new byte[ret];
								buf.get(array_byte);
								byteBuffer.append(array_byte);
								buf.clear() ;
							}else{
								break;        // -1(화일끝)이 나오면 루프를 멈춥
							}

						}

						str_data = new String(byteBuffer.toByte());

						break;
					}
					Thread.sleep(100);		// 밀리초단위
				}
			}

		}catch(Exception e){
			throw e;
		}finally{
			if (flock != null && flock.isValid()){
				try{ flock.release(); }catch(Exception ee){}
			}     
			if(in!=null){
				try{ in.close(); }catch(Exception ee){}
			}	
			if(fis!=null){
				try{ fis.close(); }catch(Exception ee){}
			}	
		}
		return str_data;
	}

	/**
	 * 파읠 특정부분의 내용을 NIO방식으로 가져온다.
	 *
	 * @param from : 내용을 가져올 파일의 전체경로
	 * @param s_point : 읽어올 시작점
	 * @param upload_size : 업로드 사이즈
	 * @return 파일내용
	 *
	*/
	public static String getNIORandomFileData(String from, long s_point, long upload_size) throws Exception {

		String str_data = "";
		RandomAccessFile ranReadFile = null;
		FileChannel readChannel = null;
		
		try{
			File fi = new File(from) ;

			if(fi.exists()){
				ranReadFile = new RandomAccessFile(fi,"r");
				readChannel = ranReadFile.getChannel();

				DataByteBuffer byteBuffer = new DataByteBuffer();

				ByteBuffer buf = ByteBuffer.allocateDirect( BUFFER );
				byte[] array_byte = null;

				ranReadFile.seek(s_point);
				long read_byte_cnt = 0L;
				int ret = 0;
				while((ret = readChannel.read(buf))!=-1){
					buf.flip();

					read_byte_cnt += ret;
					if(read_byte_cnt<=upload_size ){
						array_byte = new byte[ret];
						buf.get(array_byte);
						byteBuffer.append(array_byte);
						buf.clear();

						if(read_byte_cnt==upload_size){
							break;
						}
					}else{
						int _rest = (int)upload_size % BUFFER;	// 나머지
						if(_rest>0){
							array_byte = new byte[_rest];
							buf.get(array_byte);
							byteBuffer.append(array_byte);
							buf.clear();
						}
						break;
						/*
						int _rest = new Long(e_point - (read_byte_cnt-ret)).intValue();
						if(_rest>0){
							array_byte = new byte[_rest];
							buf.get(array_byte);
							byteBuffer.append(array_byte);
							buf.clear();
						}
						break;
						*/
					}
				}// end while

				str_data = new String(byteBuffer.toByte());
			}else{
				System.out.println("<!> File Not Found ["+from+"]");
			}

		}catch(Exception e){
			throw e;
		}finally{
			if(readChannel!=null){
				try{ readChannel.close(); }catch(Exception ee){}
			}	
			if(ranReadFile!=null){
				try{ ranReadFile.close(); }catch(Exception ee){}
			}	
		}
		return str_data;
	}

	/**
	 * 파읠 특정부분의 내용을 NIO방식으로 가져온다(File Locking)
	 *
	 * @param from : 내용을 가져올 파일의 전체경로
	 * @param s_point : 읽어올 시작점
	 * @param upload_size : 업로드 사이즈
	 * @return 파일내용
	 *
	*/
	public static String getLockNIORandomFileData(String from, long s_point, long upload_size) throws Exception {

		String str_data = "";
		RandomAccessFile ranReadFile = null;
		FileChannel readChannel = null;
		FileLock flock = null;
		
		try{
			File fi = new File(from) ;

			if(fi.exists()){
				ranReadFile = new RandomAccessFile(fi,"rw");
				readChannel = ranReadFile.getChannel();

				while(true){
					flock = readChannel.tryLock();
					if(flock!=null){
						DataByteBuffer byteBuffer = new DataByteBuffer();

						ByteBuffer buf = ByteBuffer.allocateDirect( BUFFER );
						byte[] array_byte = null;

						ranReadFile.seek(s_point);
						long read_byte_cnt = 0L;
						int ret = 0;
						while((ret = readChannel.read(buf))!=-1){
							buf.flip();

							read_byte_cnt += ret;
							if(read_byte_cnt<=upload_size ){
								array_byte = new byte[ret];
								buf.get(array_byte);
								byteBuffer.append(array_byte);
								buf.clear();

								if(read_byte_cnt==upload_size){
									break;
								}
							}else{
								int _rest = (int)upload_size % BUFFER;	// 나머지
								if(_rest>0){
									array_byte = new byte[_rest];
									buf.get(array_byte);
									byteBuffer.append(array_byte);
									buf.clear();
								}
								break;
							}
						}// end while

						str_data = new String(byteBuffer.toByte());

						break;
					}
					Thread.sleep(100);		// 밀리초단위
				}

			}else{
				System.out.println("<!> File Not Found ["+from+"]");
			}

		}catch(Exception e){
			throw e;
		}finally{
			if (flock != null && flock.isValid()){
				try{ flock.release(); }catch(Exception ee){}
			}     
			if(readChannel!=null){
				try{ readChannel.close(); }catch(Exception ee){}
			}	
			if(ranReadFile!=null){
				try{ ranReadFile.close(); }catch(Exception ee){}
			}	
		}
		return str_data;
	}

	/**
	 * 파읠의 내용을 IO방식으로 가져온다.
	 *
	 * @param from : 내용을 가져올 파일의 전체경로
	 * @return 파일내용
	 *
	*/
	public static String getIOFileData(String from) throws Exception {

		String str_data = "";
		FileInputStream fis = null;
		
		try{
			File fi = new File(from) ;
			if(fi.exists()){
				fis = new FileInputStream(fi);
				DataByteBuffer byteBuffer = new DataByteBuffer();

				byte[] buf = new byte[256];
				int len = 0;
			
				while((len = fis.read(buf,0,buf.length)) != -1)
				{
					byteBuffer.append(buf,0,len);
				}

				str_data = new String(byteBuffer.toByte());
			}

		}catch(Exception e){
			throw e;
		}finally{
			if(fis!=null){
				try{ fis.close(); }catch(Exception ee){}
			}	
		}
		return str_data;
	}

	/**
	 * 파읠의 내용을 파일로 출력한다.
	 * 
	 * @param str : 파일에 출력할 내용
	 * @param to : 내용을 출력할 파일전체경로
	 * @param iotype : 파일내용을 출력할 방식(IO, NIO)
	 * @return 
	 *
	*/
	public static void setFileData(String str, String to, String iotype) throws Exception {
		// 아직은 NIO의 속도가 IO보다 약간느려 보임
		// 추후 사용할 수 있을지몰라 NIO방식을 구현하였음
		if(iotype!=null && iotype.equals("NIO")){	
			setNIOFileData(str, to, false);
		}else{
			setIOFileData(str, to);
		}
	}

	/**
	 * 파읠의 내용을 NIO방식으로 파일로 출력한다.
	 *
	 * @param str : 파일에 출력할 내용
	 * @param to : 내용을 출력할 파일전체경로
	 * @param flag : 기존파일에 덮어쓸건지 말건지
	 * @return 
	 *
	*/
	public static void setNIOFileData(String str, String to, boolean flag) throws Exception {
		File fo = null;
		FileOutputStream fos = null;
		FileChannel foc = null;
		
		try{
			fo = new File(to);
			fos = new FileOutputStream(fo, flag);
			foc = fos.getChannel();
			ByteBuffer buf = ByteBuffer.wrap(str.getBytes());
			foc.write(buf);
			buf.clear();
		}catch(Exception e){
			throw e;
		}finally{
			if(foc!=null){
				try{ foc.close(); }catch(Exception ee){}
			}	
			if(fos!=null){
				try{ fos.close(); }catch(Exception ee){}
			}	
		}
	}

	/**
	 * String의 내용을 NIO방식으로 파일로 출력한다.
	 *
	 * @param str : 파일에 출력할 내용
	 * @param to : 내용을 출력할 파일전체경로
	 * @param s_point : 출력할 초기 위치
	 * @return 
	 *
	*/
	public static void setNIORandomFileDataOfString(String str, String to, long s_point) throws Exception {
		File fo = null;
		RandomAccessFile fos = null;
		FileChannel foc = null;
		
		try{
			fo = new File(to);
			fos = new RandomAccessFile(fo, "rw");
			fos.seek(s_point);
			foc = fos.getChannel();
			ByteBuffer buf = ByteBuffer.wrap(str.getBytes());
			foc.write(buf);
			buf.clear();
		}catch(Exception e){
			throw e;
		}finally{
			if(foc!=null){
				try{ foc.close(); }catch(Exception ee){}
			}	
			if(fos!=null){
				try{ fos.close(); }catch(Exception ee){}
			}	
		}
	}

	/**
	 * InputStream내용을 파일에 추가한다.
	 *
	 * @param in : 내용을 가져올 InputStream
	 * @param to : 내용을 출력할 파일전체경로
	 * @param s_point : 출력 시작점
	 * @return 
	 *
	*/
	public static void setRandomFileDataOfStream(InputStream in, String to, long s_point) throws Exception {

		RandomAccessFile writeFile = null;

		try{
			File fo = new File(to);
			writeFile = new RandomAccessFile(fo,"rw");
			writeFile.seek(s_point);

			byte[] buf = new byte[BUFFER];
			int ret = 0;
			while((ret = in.read(buf))!=-1){
				writeFile.write(buf,0,ret);
			}

		}catch(Exception e){
			throw e;
		}finally{
			if(writeFile!=null){
				try{ writeFile.close(); }catch(Exception ee){}
			}	
		}
	}

	/**
	 * 특정내용을 파일에 추가한다.
	 *
	 * @param from : 내용을 가져올 파일의 전체경로
	 * @param to : 내용을 출력할 파일전체경로
	 * @param s_point : 출력 시작점
	 * @return 
	 *
	*/
	public static void setNIORandomFileData(String from, String to, long s_point) throws Exception {

		FileInputStream fis = null;
		RandomAccessFile writeFile = null;
		FileChannel readChannel = null;
		FileChannel writeChannel = null;

		try{
			File fi = new File(from);
			if(fi.exists()){
				fis = new FileInputStream(fi);
				readChannel = fis.getChannel();

				File fo = new File(to);
				writeFile = new RandomAccessFile(fo,"rw");
				writeFile.seek(s_point);
				writeChannel = writeFile.getChannel();

				ByteBuffer buf = ByteBuffer.allocateDirect( BUFFER );
				int ret = 0;
				while((ret = readChannel.read(buf))!=-1){
					buf.flip();
					writeChannel.write(buf);
					buf.clear();
				}

			}
		}catch(Exception e){
			throw e;
		}finally{
			if(readChannel!=null){
				try{ readChannel.close(); }catch(Exception ee){}
			}	
			if(fis!=null){
				try{ fis.close(); }catch(Exception ee){}
			}	
			if(writeChannel!=null){
				try{ writeChannel.close(); }catch(Exception ee){}
			}	
			if(writeFile!=null){
				try{ writeFile.close(); }catch(Exception ee){}
			}	
		}
	}

	/**
	 * 파읠의 내용을 IO방식으로 파일로 출력한다.
	 *
	 * @param str : 파일에 출력할 내용
	 * @param to : 내용을 출력할 파일전체경로
	 * @return 
	 *
	*/
	public static void setIOFileData(String str, String to) throws Exception {
		File fo = null;
		FileOutputStream fos = null;
		BufferedOutputStream fout = null;
		
		try{
			fo = new File(to);
			fos = new FileOutputStream(fo, false);
			fout = new BufferedOutputStream(fos);
            byte[] str_byte = str.getBytes();
			
			int len = str_byte.length;
			fout.write(str_byte, 0, len);

		}catch(Exception e){
			throw e;
		}finally{
			if(fos!=null){
				try{ fos.close(); }catch(Exception ee){}
			}	
			if(fout!=null){
				try{ fout.close(); }catch(Exception ee){}
			}	
		}
	}

	/**
	 * @author KJH
	 * 파일의 디렉토리 뒤에 separator를 추가하여 리턴한다.
	 *
	 * @param filepath : 디렉토리 
	 * @return separator로 끝나는 디렉토리
	 *
	*/
	public static String getFilePath(String filepath) {
		String filedir = filepath;
		if(filedir!=null && !filedir.equals("")){
			if(!filedir.endsWith(File.separator)){
				filedir += File.separator;
			}
		}
		return filedir;
	}

	/**
	 * @author KJH
	 * 파일 디렉토리를 리턴한다.
	 *
	 * @param 기본디렉토리
	 * @param 사용자아이디
	 * @param 디렉토리 depth
	 * @return 디렉토리
	 *
	*/
    public static String getPath(String _baseDir, String userid, int depth){
		String path = null;
		if(depth==2){
			path = new StringBuffer(_baseDir)
				.append(userid.charAt(0)).append(File.separator)
				.append(userid).append(File.separator).toString();
		}else if(depth>2){
			if(userid.length()<2 || StringUtil.isSpecialChar(userid.substring(1,2), "")){
				path = new StringBuffer(_baseDir)
					.append(userid.charAt(0)).append(File.separator)
					.append(userid.charAt(0)).append(File.separator)
					.append(userid).append(File.separator).toString();
			}else{
				path = new StringBuffer(_baseDir)
					.append(userid.charAt(0)).append(File.separator)
					.append(userid.charAt(1)).append(File.separator)
					.append(userid).append(File.separator).toString();
			}
		}
		return path;
	}

    /** 
     * @author KJH 
     * 디렉토리에 존재하는 파일을 삭제한다. 
     *   
     * @param attachFileDir : 디렉토리
     *
     */  
    public static boolean clearUploadFile(String attachFileDir) {
		boolean ret_val = true;
		File fileDir = new File(attachFileDir);
		try{    
			if(fileDir.exists()){
				if(fileDir.isDirectory()){
					File[] fileList = fileDir.listFiles();
					int cnt = fileList.length;
					for(int i=0; i<cnt; i++){
						if(fileList[i].isFile()){
							fileList[i].delete();   
						}                   
					}
				}
				fileDir.delete();
			}     
			ret_val = true;
		}catch(Exception e){
			ret_val = false;
			e.printStackTrace();
		}  
		return ret_val;
    }   

}
